/**
 * @author       Richard Davey <rich@photonstorm.com>
 * @copyright    2016 Photon Storm Ltd.
 * @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
 */

/**
 * A collection of useful mathematical functions.
 *
 * These are normally accessed through `game.math`.
 *
 * @class Phaser.Math
 * @static
 * @see {@link Phaser.Utils}
 * @see {@link Phaser.ArrayUtils}
 */
Phaser.Math = {

    /**
     * Twice PI.
     * @property {number} Phaser.Math#PI2
     * @default ~6.283
     */
    PI2: Math.PI * 2,

    /**
     * Half PI.
     * @property {number} Phaser.Math#HALF_PI
     * @default ~1.570
     */
    HALF_PI: Math.PI * 0.5,

    /**
     * Degrees to Radians factor.
     * @property {number} Phaser.Math#DEG_TO_RAD
     */
    DEG_TO_RAD: Math.PI / 180,

    /**
     * Degrees to Radians factor.
     * @property {number} Phaser.Math#RAD_TO_DEG
     */
    RAD_TO_DEG: 180 / Math.PI,

    /**
     * Convert degrees to radians.
     *
     * @method Phaser.Math#degToRad
     * @param {number} degrees - Angle in degrees.
     * @return {number} Angle in radians.
     */
    degToRad: function (degrees)
    {
        return degrees * Phaser.Math.DEG_TO_RAD;
    },

    /**
     * Convert radians to degrees.
     *
     * @method Phaser.Math#radToDeg
     * @param {number} radians - Angle in radians.
     * @return {number} Angle in degrees
     */
    radToDeg: function (radians)
    {
        return radians * Phaser.Math.RAD_TO_DEG;
    },

    /**
     * Given a number, this function returns the closest number that is a power of two.
     * This function is from the Starling Framework.
     *
     * @method Phaser.Math#getNextPowerOfTwo
     * @param {number} value - The value to get the closest power of two from.
     * @return {number} The closest number that is a power of two.
     */
    getNextPowerOfTwo: function (value)
    {
        if (value > 0 && (value & (value - 1)) === 0)
        {
            //  http://goo.gl/D9kPj
            return value;
        }
        else
        {
            var result = 1;

            while (result < value)
            {
                result <<= 1;
            }

            return result;
        }
    },

    /**
     * Checks if the given dimensions make a power of two texture.
     *
     * @method Phaser.Math#isPowerOfTwo
     * @param {number} width - The width to check.
     * @param {number} height - The height to check.
     * @return {boolean} True if the width and height are a power of two.
     */
    isPowerOfTwo: function (width, height)
    {
        return (width > 0 && (width & (width - 1)) === 0 && height > 0 && (height & (height - 1)) === 0);
    },

    /**
     * Returns a random float in the range `[min, max)`. If these parameters are not in order than they will be put in order.
     * Default is 0 for `min` and 1 for `max`.
     *
     * @method Phaser.Math#random
     * @param {number} min - The minimum value. Must be a Number.
     * @param {number} max - The maximum value. Must be a Number.
     * @return {number} A floating point number between min (inclusive) and max (exclusive).
     */
    random: function (min, max)
    {
        if (min === undefined) { min = 0; }
        if (max === undefined) { max = 1; }

        if (min === max)
        {
            return min;
        }

        if (min > max)
        {
            var temp = min;
            min = max;
            max = temp;
        }

        return (Math.random() * (max - min) + min);
    },

    /**
     * Returns a random integer in the range `[min, max]`. If these parameters are not in order than they will be put in order.
     * Default is 0 for `min` and 1 for `max`.
     *
     * @method Phaser.Math#between
     * @param {number} min - The minimum value. Must be a Number.
     * @param {number} max - The maximum value. Must be a Number.
     * @return {number} An integer between min (inclusive) and max (inclusive).
     */
    between: function (min, max)
    {
        if (min === undefined) { min = 0; }
        if (max === undefined) { max = 1; }

        if (min === max)
        {
            return min;
        }

        if (min > max)
        {
            var temp = min;
            min = max;
            max = temp;
        }

        min = Math.ceil(min);
        max = Math.floor(max);

        return Math.floor(Math.random() * (max - min + 1)) + min;
    },

    /**
     * Two number are fuzzyEqual if their difference is less than epsilon.
     *
     * @method Phaser.Math#fuzzyEqual
     * @param {number} a - The first number to compare.
     * @param {number} b - The second number to compare.
     * @param {number} [epsilon=0.0001] - The epsilon (a small value used in the calculation)
     * @return {boolean} True if |a-b|<epsilon
     */
    fuzzyEqual: function (a, b, epsilon)
    {
        if (epsilon === undefined) { epsilon = 0.0001; }

        return Math.abs(a - b) < epsilon;
    },

    /**
     * `a` is fuzzyLessThan `b` if it is less than b + epsilon.
     *
     * @method Phaser.Math#fuzzyLessThan
     * @param {number} a - The first number to compare.
     * @param {number} b - The second number to compare.
     * @param {number} [epsilon=0.0001] - The epsilon (a small value used in the calculation)
     * @return {boolean} True if a<b+epsilon
     */
    fuzzyLessThan: function (a, b, epsilon)
    {
        if (epsilon === undefined) { epsilon = 0.0001; }

        return a < b + epsilon;
    },

    /**
     * `a` is fuzzyGreaterThan `b` if it is more than b - epsilon.
     *
     * @method Phaser.Math#fuzzyGreaterThan
     * @param {number} a - The first number to compare.
     * @param {number} b - The second number to compare.
     * @param {number} [epsilon=0.0001] - The epsilon (a small value used in the calculation)
     * @return {boolean} True if a>b+epsilon
     */
    fuzzyGreaterThan: function (a, b, epsilon)
    {
        if (epsilon === undefined) { epsilon = 0.0001; }

        return a > b - epsilon;
    },

    /**
     * Applies a fuzzy ceil to the given value.
     *
     * @method Phaser.Math#fuzzyCeil
     * @param {number} val - The value to ceil.
     * @param {number} [epsilon=0.0001] - The epsilon (a small value used in the calculation)
     * @return {number} ceiling(val-epsilon)
     */
    fuzzyCeil: function (val, epsilon)
    {
        if (epsilon === undefined) { epsilon = 0.0001; }

        return Math.ceil(val - epsilon);
    },

    /**
     * Applies a fuzzy floor to the given value.
     *
     * @method Phaser.Math#fuzzyFloor
     * @param {number} val - The value to floor.
     * @param {number} [epsilon=0.0001] - The epsilon (a small value used in the calculation)
     * @return {number} floor(val+epsilon)
     */
    fuzzyFloor: function (val, epsilon)
    {
        if (epsilon === undefined) { epsilon = 0.0001; }

        return Math.floor(val + epsilon);
    },

    /**
     * Averages all values passed to the function and returns the result.
     *
     * @method Phaser.Math#average
     * @params {...number} The numbers to average
     * @return {number} The average of all given values.
     */
    average: function ()
    {
        var sum = 0;
        var len = arguments.length;

        for (var i = 0; i < len; i++)
        {
            sum += (+arguments[i]);
        }

        return sum / len;
    },

    /**
     * @method Phaser.Math#shear
     * @param {number} n
     * @return {number} n mod 1
     */
    shear: function (n)
    {
        return n % 1;
    },

    /**
     * Snap a value to nearest grid slice, using rounding.
     *
     * Example: if you have an interval gap of 5 and a position of 12... you will snap to 10 whereas 14 will snap to 15.
     *
     * @method Phaser.Math#snapTo
     * @param {number} input - The value to snap.
     * @param {number} gap - The interval gap of the grid.
     * @param {number} [start=0] - Optional starting offset for gap.
     * @return {number} The snapped value.
     */
    snapTo: function (input, gap, start)
    {
        if (start === undefined) { start = 0; }

        if (gap === 0)
        {
            return input;
        }

        input -= start;
        input = gap * Math.round(input / gap);

        return start + input;
    },

    /**
     * Snap a value to nearest grid slice, using floor.
     *
     * Example: if you have an interval gap of 5 and a position of 12... you will snap to 10.
     * As will 14 snap to 10... but 16 will snap to 15.
     *
     * @method Phaser.Math#snapToFloor
     * @param {number} input - The value to snap.
     * @param {number} gap - The interval gap of the grid.
     * @param {number} [start=0] - Optional starting offset for gap.
     * @return {number} The snapped value.
     */
    snapToFloor: function (input, gap, start)
    {
        if (start === undefined) { start = 0; }

        if (gap === 0)
        {
            return input;
        }

        input -= start;
        input = gap * Math.floor(input / gap);

        return start + input;
    },

    /**
     * Snap a value to nearest grid slice, using ceil.
     *
     * Example: if you have an interval gap of 5 and a position of 12... you will snap to 15.
     * As will 14 will snap to 15... but 16 will snap to 20.
     *
     * @method Phaser.Math#snapToCeil
     * @param {number} input - The value to snap.
     * @param {number} gap - The interval gap of the grid.
     * @param {number} [start=0] - Optional starting offset for gap.
     * @return {number} The snapped value.
     */
    snapToCeil: function (input, gap, start)
    {
        if (start === undefined) { start = 0; }

        if (gap === 0)
        {
            return input;
        }

        input -= start;
        input = gap * Math.ceil(input / gap);

        return start + input;
    },

    /**
     * Round to some place comparative to a `base`, default is 10 for decimal place.
     * The `place` is represented by the power applied to `base` to get that place.
     *
     *     e.g. 2000/7 ~= 285.714285714285714285714 ~= (bin)100011101.1011011011011011
     *
     *     roundTo(2000/7,3) === 0
     *     roundTo(2000/7,2) == 300
     *     roundTo(2000/7,1) == 290
     *     roundTo(2000/7,0) == 286
     *     roundTo(2000/7,-1) == 285.7
     *     roundTo(2000/7,-2) == 285.71
     *     roundTo(2000/7,-3) == 285.714
     *     roundTo(2000/7,-4) == 285.7143
     *     roundTo(2000/7,-5) == 285.71429
     *
     *     roundTo(2000/7,3,2)  == 288       -- 100100000
     *     roundTo(2000/7,2,2)  == 284       -- 100011100
     *     roundTo(2000/7,1,2)  == 286       -- 100011110
     *     roundTo(2000/7,0,2)  == 286       -- 100011110
     *     roundTo(2000/7,-1,2) == 285.5     -- 100011101.1
     *     roundTo(2000/7,-2,2) == 285.75    -- 100011101.11
     *     roundTo(2000/7,-3,2) == 285.75    -- 100011101.11
     *     roundTo(2000/7,-4,2) == 285.6875  -- 100011101.1011
     *     roundTo(2000/7,-5,2) == 285.71875 -- 100011101.10111
     *
     * Note what occurs when we round to the 3rd space (8ths place), 100100000, this is to be assumed
     * because we are rounding 100011.1011011011011011 which rounds up.
     *
     * @method Phaser.Math#roundTo
     * @param {number} value - The value to round.
     * @param {number} [place=0] - The place to round to.
     * @param {number} [base=10] - The base to round in. Default is 10 for decimal.
     * @return {number} The rounded value.
     */
    roundTo: function (value, place, base)
    {
        if (place === undefined) { place = 0; }
        if (base === undefined) { base = 10; }

        var p = Math.pow(base, -place);

        return Math.round(value * p) / p;
    },

    /**
     * Floors to some place comparative to a `base`, default is 10 for decimal place.
     * The `place` is represented by the power applied to `base` to get that place.
     *
     * @method Phaser.Math#floorTo
     * @param {number} value - The value to round.
     * @param {number} [place=0] - The place to round to.
     * @param {number} [base=10] - The base to round in. Default is 10 for decimal.
     * @return {number} The rounded value.
     */
    floorTo: function (value, place, base)
    {
        if (place === undefined) { place = 0; }
        if (base === undefined) { base = 10; }

        var p = Math.pow(base, -place);

        return Math.floor(value * p) / p;
    },

    /**
     * Ceils to some place comparative to a `base`, default is 10 for decimal place.
     * The `place` is represented by the power applied to `base` to get that place.
     *
     * @method Phaser.Math#ceilTo
     * @param {number} value - The value to round.
     * @param {number} [place=0] - The place to round to.
     * @param {number} [base=10] - The base to round in. Default is 10 for decimal.
     * @return {number} The rounded value.
     */
    ceilTo: function (value, place, base)
    {
        if (place === undefined) { place = 0; }
        if (base === undefined) { base = 10; }

        var p = Math.pow(base, -place);

        return Math.ceil(value * p) / p;
    },

    /**
     * Truncates a number, removing any fractional part.
     * Same as round-towards-zero.
     *
     * @method Phaser.Math#trunc
     * @param {number} value - The value to truncate.
     * @return {number} The truncated value.
     */
    trunc: function (value)
    {
        if (!isFinite(value))
        {
            return value;
        }

        return (value - value % 1) || (value < 0 ? -0 : value === 0 ? value : 0);
    },

    /**
     * Rotates currentAngle towards targetAngle, taking the shortest rotation distance.
     * The lerp argument is the amount to rotate by in this call.
     *
     * @method Phaser.Math#rotateToAngle
     * @param {number} currentAngle - The current angle, in radians.
     * @param {number} targetAngle - The target angle to rotate to, in radians.
     * @param {number} [lerp=0.05] - The lerp value to add to the current angle.
     * @return {number} The adjusted angle.
     */
    rotateToAngle: function (currentAngle, targetAngle, lerp)
    {
        if (lerp === undefined) { lerp = 0.05; }

        if (currentAngle === targetAngle)
        {
            return currentAngle;
        }

        if (Math.abs(targetAngle - currentAngle) <= lerp || Math.abs(targetAngle - currentAngle) >= (Phaser.Math.PI2 - lerp))
        {
            currentAngle = targetAngle;
        }
        else
        {
            if (Math.abs(targetAngle - currentAngle) > Math.PI)
            {
                if (targetAngle < currentAngle)
                {
                    targetAngle += Phaser.Math.PI2;
                }
                else
                {
                    targetAngle -= Phaser.Math.PI2;
                }
            }

            if (targetAngle > currentAngle)
            {
                currentAngle += lerp;
            }
            else if (targetAngle < currentAngle)
            {
                currentAngle -= lerp;
            }
        }

        return currentAngle;
    },

    /**
     * Gets the shortest angle between `angle1` and `angle2`.
     * Both angles must be in the range -180 to 180, which is the same clamped
     * range that `sprite.angle` uses, so you can pass in two sprite angles to
     * this method, and get the shortest angle back between the two of them.
     *
     * The angle returned will be in the same range. If the returned angle is
     * greater than 0 then it's a counter-clockwise rotation, if < 0 then it's
     * a clockwise rotation.
     *
     * @method Phaser.Math#getShortestAngle
     * @param {number} angle1 - The first angle. In the range -180 to 180.
     * @param {number} angle2 - The second angle. In the range -180 to 180.
     * @return {number} The shortest angle, in degrees. If greater than zero it's a counter-clockwise rotation.
     */
    getShortestAngle: function (angle1, angle2)
    {
        var difference = angle2 - angle1;

        if (difference === 0)
        {
            return 0;
        }

        var times = Math.floor((difference - (-180)) / 360);

        return difference - (times * 360);
    },

    /**
     * Find the angle of a segment from (x1, y1) -> (x2, y2).
     *
     * @method Phaser.Math#angleBetween
     * @param {number} x1 - The x coordinate of the first value.
     * @param {number} y1 - The y coordinate of the first value.
     * @param {number} x2 - The x coordinate of the second value.
     * @param {number} y2 - The y coordinate of the second value.
     * @return {number} The angle, in radians.
     */
    angleBetween: function (x1, y1, x2, y2)
    {
        return Math.atan2(y2 - y1, x2 - x1);
    },

    /**
     * Find the angle of a segment from (x1, y1) -> (x2, y2).
     *
     * The difference between this method and Math.angleBetween is that this assumes the y coordinate travels
     * down the screen.
     *
     * @method Phaser.Math#angleBetweenY
     * @param {number} x1 - The x coordinate of the first value.
     * @param {number} y1 - The y coordinate of the first value.
     * @param {number} x2 - The x coordinate of the second value.
     * @param {number} y2 - The y coordinate of the second value.
     * @return {number} The angle, in radians.
     */
    angleBetweenY: function (x1, y1, x2, y2)
    {
        return Math.atan2(x2 - x1, y2 - y1);
    },

    /**
     * Find the angle of a segment from (point1.x, point1.y) -> (point2.x, point2.y).
     *
     * @method Phaser.Math#angleBetweenPoints
     * @param {Phaser.Point} point1 - The first point.
     * @param {Phaser.Point} point2 - The second point.
     * @return {number} The angle between the two points, in radians.
     */
    angleBetweenPoints: function (point1, point2)
    {
        return Math.atan2(point2.y - point1.y, point2.x - point1.x);
    },

    /**
     * Find the angle of a segment from (point1.x, point1.y) -> (point2.x, point2.y).
     * @method Phaser.Math#angleBetweenPointsY
     * @param {Phaser.Point} point1
     * @param {Phaser.Point} point2
     * @return {number} The angle, in radians.
     */
    angleBetweenPointsY: function (point1, point2)
    {
        return Math.atan2(point2.x - point1.x, point2.y - point1.y);
    },

    /**
     * Reverses an angle.
     * @method Phaser.Math#reverseAngle
     * @param {number} angleRad - The angle to reverse, in radians.
     * @return {number} The reverse angle, in radians.
     */
    reverseAngle: function (angleRad)
    {
        return this.normalizeAngle(angleRad + Math.PI, true);
    },

    /**
     * Normalizes an angle to the [0,2pi) range.
     * @method Phaser.Math#normalizeAngle
     * @param {number} angleRad - The angle to normalize, in radians.
     * @return {number} The angle, fit within the [0,2pi] range, in radians.
     */
    normalizeAngle: function (angleRad)
    {
        angleRad = angleRad % (2 * Math.PI);
        return angleRad >= 0 ? angleRad : angleRad + 2 * Math.PI;
    },

    /**
     * Adds the given amount to the value, but never lets the value go over the specified maximum.
     *
     * @method Phaser.Math#maxAdd
     * @param {number} value - The value to add the amount to.
     * @param {number} amount - The amount to add to the value.
     * @param {number} max - The maximum the value is allowed to be.
     * @return {number} The new value.
     */
    maxAdd: function (value, amount, max)
    {
        return Math.min(value + amount, max);
    },

    /**
     * Subtracts the given amount from the value, but never lets the value go below the specified minimum.
     *
     * @method Phaser.Math#minSub
     * @param {number} value - The base value.
     * @param {number} amount - The amount to subtract from the base value.
     * @param {number} min - The minimum the value is allowed to be.
     * @return {number} The new value.
     */
    minSub: function (value, amount, min)
    {
        return Math.max(value - amount, min);
    },

    /**
     * Ensures that the value always stays between min and max, by wrapping the value around.
     *
     * If `max` is not larger than `min` the result is 0.
     *
     * @method Phaser.Math#wrap
     * @param {number} value - The value to wrap.
     * @param {number} min - The minimum the value is allowed to be.
     * @param {number} max - The maximum the value is allowed to be, should be larger than `min`.
     * @return {number} The wrapped value.
     */
    wrap: function (value, min, max)
    {
        var range = max - min;

        if (range <= 0)
        {
            return 0;
        }

        var result = (value - min) % range;

        if (result < 0)
        {
            result += range;
        }

        return result + min;
    },

    /**
     * Adds value to amount and ensures that the result always stays between 0 and max, by wrapping the value around.
     *
     * Values _must_ be positive integers, and are passed through Math.abs. See {@link Phaser.Math#wrap} for an alternative.
     *
     * @method Phaser.Math#wrapValue
     * @param {number} value - The value to add the amount to.
     * @param {number} amount - The amount to add to the value.
     * @param {number} max - The maximum the value is allowed to be.
     * @return {number} The wrapped value.
     */
    wrapValue: function (value, amount, max)
    {
        var diff;
        value = Math.abs(value);
        amount = Math.abs(amount);
        max = Math.abs(max);
        diff = (value + amount) % max;

        return diff;
    },

    /**
     * Returns true if the number given is odd.
     *
     * @method Phaser.Math#isOdd
     * @param {integer} n - The number to check.
     * @return {boolean} True if the given number is odd. False if the given number is even.
     */
    isOdd: function (n)
    {
        // Does not work with extremely large values
        return !!(n & 1);
    },

    /**
     * Returns true if the number given is even.
     *
     * @method Phaser.Math#isEven
     * @param {integer} n - The number to check.
     * @return {boolean} True if the given number is even. False if the given number is odd.
     */
    isEven: function (n)
    {
        // Does not work with extremely large values
        return !(n & 1);
    },

    /**
     * Variation of Math.min that can be passed either an array of numbers or the numbers as parameters.
     *
     * Prefer the standard `Math.min` function when appropriate.
     *
     * @method Phaser.Math#min
     * @return {number} The lowest value from those given.
     * @see {@link http://jsperf.com/math-s-min-max-vs-homemade}
     */
    min: function ()
    {
        if (arguments.length === 1 && typeof arguments[0] === 'object')
        {
            var data = arguments[0];
        }
        else
        {
            var data = arguments;
        }

        for (var i = 1, min = 0, len = data.length; i < len; i++)
        {
            if (data[i] < data[min])
            {
                min = i;
            }
        }

        return data[min];
    },

    /**
     * Variation of Math.max that can be passed either an array of numbers or the numbers as parameters.
     *
     * Prefer the standard `Math.max` function when appropriate.
     *
     * @method Phaser.Math#max
     * @return {number} The largest value from those given.
     * @see {@link http://jsperf.com/math-s-min-max-vs-homemade}
     */
    max: function ()
    {
        if (arguments.length === 1 && typeof arguments[0] === 'object')
        {
            var data = arguments[0];
        }
        else
        {
            var data = arguments;
        }

        for (var i = 1, max = 0, len = data.length; i < len; i++)
        {
            if (data[i] > data[max])
            {
                max = i;
            }
        }

        return data[max];
    },

    /**
     * Variation of Math.min that can be passed a property and either an array of objects or the objects as parameters.
     * It will find the lowest matching property value from the given objects.
     *
     * @method Phaser.Math#minProperty
     * @return {number} The lowest value from those given.
     */
    minProperty: function (property)
    {
        if (arguments.length === 2 && typeof arguments[1] === 'object')
        {
            var data = arguments[1];
        }
        else
        {
            var data = arguments.slice(1);
        }

        for (var i = 1, min = 0, len = data.length; i < len; i++)
        {
            if (data[i][property] < data[min][property])
            {
                min = i;
            }
        }

        return data[min][property];
    },

    /**
     * Variation of Math.max that can be passed a property and either an array of objects or the objects as parameters.
     * It will find the largest matching property value from the given objects.
     *
     * @method Phaser.Math#maxProperty
     * @return {number} The largest value from those given.
     */
    maxProperty: function (property)
    {
        if (arguments.length === 2 && typeof arguments[1] === 'object')
        {
            var data = arguments[1];
        }
        else
        {
            var data = arguments.slice(1);
        }

        for (var i = 1, max = 0, len = data.length; i < len; i++)
        {
            if (data[i][property] > data[max][property])
            {
                max = i;
            }
        }

        return data[max][property];
    },

    /**
     * Keeps an angle value between -180 and +180; or -PI and PI if radians.
     *
     * @method Phaser.Math#wrapAngle
     * @param {number} angle - The angle value to wrap
     * @param {boolean} [radians=false] - Set to `true` if the angle is given in radians, otherwise degrees is expected.
     * @return {number} The new angle value; will be the same as the input angle if it was within bounds.
     */
    wrapAngle: function (angle, radians)
    {
        return radians ? this.wrap(angle, -Math.PI, Math.PI) : this.wrap(angle, -180, 180);
    },

    /**
     * A Linear Interpolation Method, mostly used by Phaser.Tween.
     *
     * @method Phaser.Math#linearInterpolation
     * @param {Array} v - The input array of values to interpolate between.
     * @param {number} k - The amount of interpolation, between 0 (start) and 1 (end).
     * @return {number} The interpolated value
     */
    linearInterpolation: function (v, k)
    {
        var m = v.length - 1;
        var f = m * k;
        var i = Math.floor(f);

        if (k < 0)
        {
            return this.linear(v[0], v[1], f);
        }

        if (k > 1)
        {
            return this.linear(v[m], v[m - 1], m - f);
        }

        return this.linear(v[i], v[i + 1 > m ? m : i + 1], f - i);
    },

    /**
     * A Bezier Interpolation Method, mostly used by Phaser.Tween.
     *
     * @method Phaser.Math#bezierInterpolation
     * @param {Array} v - The input array of values to interpolate between.
     * @param {number} k - The percentage of interpolation, between 0 and 1.
     * @return {number} The interpolated value
     */
    bezierInterpolation: function (v, k)
    {
        var b = 0;
        var n = v.length - 1;

        for (var i = 0; i <= n; i++)
        {
            b += Math.pow(1 - k, n - i) * Math.pow(k, i) * v[i] * this.bernstein(n, i);
        }

        return b;
    },

    /**
     * A Catmull Rom Interpolation Method, mostly used by Phaser.Tween.
     *
     * @method Phaser.Math#catmullRomInterpolation
     * @param {Array} v - The input array of values to interpolate between.
     * @param {number} k - The percentage of interpolation, between 0 and 1.
     * @return {number} The interpolated value
     */
    catmullRomInterpolation: function (v, k)
    {
        var m = v.length - 1;
        var f = m * k;
        var i = Math.floor(f);

        if (v[0] === v[m])
        {
            if (k < 0)
            {
                i = Math.floor(f = m * (1 + k));
            }

            return this.catmullRom(v[(i - 1 + m) % m], v[i], v[(i + 1) % m], v[(i + 2) % m], f - i);
        }
        else
        {
            if (k < 0)
            {
                return v[0] - (this.catmullRom(v[0], v[0], v[1], v[1], -f) - v[0]);
            }

            if (k > 1)
            {
                return v[m] - (this.catmullRom(v[m], v[m], v[m - 1], v[m - 1], f - m) - v[m]);
            }

            return this.catmullRom(v[i ? i - 1 : 0], v[i], v[m < i + 1 ? m : i + 1], v[m < i + 2 ? m : i + 2], f - i);
        }
    },

    /**
     * Calculates a linear (interpolation) value over t.
     *
     * @method Phaser.Math#linear
     * @param {number} p0
     * @param {number} p1
     * @param {number} t - A value between 0 and 1.
     * @return {number}
     */
    linear: function (p0, p1, t)
    {
        return (p1 - p0) * t + p0;
    },

    /**
     * @method Phaser.Math#bernstein
     * @protected
     * @param {number} n
     * @param {number} i
     * @return {number}
     */
    bernstein: function (n, i)
    {
        return this.factorial(n) / this.factorial(i) / this.factorial(n - i);
    },

    /**
     * @method Phaser.Math#factorial
     * @param {number} value - the number you want to evaluate
     * @return {number}
     */
    factorial: function (value)
    {
        if (value === 0)
        {
            return 1;
        }

        var res = value;

        while(--value)
        {
            res *= value;
        }

        return res;
    },

    /**
     * Calculates a catmum rom value.
     *
     * @method Phaser.Math#catmullRom
     * @protected
     * @param {number} p0
     * @param {number} p1
     * @param {number} p2
     * @param {number} p3
     * @param {number} t
     * @return {number}
     */
    catmullRom: function (p0, p1, p2, p3, t)
    {
        var v0 = (p2 - p0) * 0.5,
            v1 = (p3 - p1) * 0.5,
            t2 = t * t,
            t3 = t * t2;

        return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
    },

    /**
     * The absolute difference between two values.
     *
     * @method Phaser.Math#difference
     * @param {number} a - The first value to check.
     * @param {number} b - The second value to check.
     * @return {number} The absolute difference between the two values.
     */
    difference: function (a, b)
    {
        return Math.abs(a - b);
    },

    /**
     * Round to the next whole number _away_ from zero.
     *
     * @method Phaser.Math#roundAwayFromZero
     * @param {number} value - Any number.
     * @return {integer} The rounded value of that number.
     */
    roundAwayFromZero: function (value)
    {
        // "Opposite" of truncate.
        return (value > 0) ? Math.ceil(value) : Math.floor(value);
    },

    /**
     * Generate a sine and cosine table simultaneously and extremely quickly.
     * The parameters allow you to specify the length, amplitude and frequency of the wave.
     * This generator is fast enough to be used in real-time.
     * Code based on research by Franky of scene.at
     *
     * @method Phaser.Math#sinCosGenerator
     * @param {number} length - The length of the wave
     * @param {number} sinAmplitude - The amplitude to apply to the sine table (default 1.0) if you need values between say -+ 125 then give 125 as the value
     * @param {number} cosAmplitude - The amplitude to apply to the cosine table (default 1.0) if you need values between say -+ 125 then give 125 as the value
     * @param {number} frequency  - The frequency of the sine and cosine table data
     * @return {{sin:number[], cos:number[]}} Returns the table data.
     */
    sinCosGenerator: function (length, sinAmplitude, cosAmplitude, frequency)
    {
        if (sinAmplitude === undefined) { sinAmplitude = 1.0; }
        if (cosAmplitude === undefined) { cosAmplitude = 1.0; }
        if (frequency === undefined) { frequency = 1.0; }

        var sin = sinAmplitude;
        var cos = cosAmplitude;
        var frq = frequency * Math.PI / length;

        var cosTable = [];
        var sinTable = [];

        for (var c = 0; c < length; c++)
        {
            cos -= sin * frq;
            sin += cos * frq;

            cosTable[c] = cos;
            sinTable[c] = sin;
        }

        return { sin: sinTable, cos: cosTable, length: length };
    },

    /**
     * Returns the length of the hypotenuse connecting two segments of given lengths.
     *
     * @method Phaser.Math#hypot
     * @param {number} a
     * @param {number} b
     * @return {number} The length of the hypotenuse connecting the given lengths.
     */
    hypot: function (a, b)
    {
        return Math.sqrt(a * a + b * b);
    },

    /**
     * Returns the euclidian distance between the two given set of coordinates.
     *
     * @method Phaser.Math#distance
     * @param {number} x1
     * @param {number} y1
     * @param {number} x2
     * @param {number} y2
     * @return {number} The distance between the two sets of coordinates.
     */
    distance: function (x1, y1, x2, y2)
    {
        var dx = x1 - x2;
        var dy = y1 - y2;

        return Math.sqrt(dx * dx + dy * dy);
    },

    /**
     * Returns the euclidean distance squared between the two given set of
     * coordinates (cuts out a square root operation before returning).
     *
     * @method Phaser.Math#distanceSq
     * @param {number} x1
     * @param {number} y1
     * @param {number} x2
     * @param {number} y2
     * @return {number} The distance squared between the two sets of coordinates.
     */
    distanceSq: function (x1, y1, x2, y2)
    {
        var dx = x1 - x2;
        var dy = y1 - y2;

        return dx * dx + dy * dy;
    },

    /**
     * Returns the distance between the two given set of coordinates at the power given.
     *
     * @method Phaser.Math#distancePow
     * @param {number} x1
     * @param {number} y1
     * @param {number} x2
     * @param {number} y2
     * @param {number} [pow=2]
     * @return {number} The distance between the two sets of coordinates.
     */
    distancePow: function (x1, y1, x2, y2, pow)
    {
        if (pow === undefined) { pow = 2; }

        return Math.sqrt(Math.pow(x2 - x1, pow) + Math.pow(y2 - y1, pow));
    },

    /**
     * Force a value within the boundaries by clamping it to the range `min`, `max`.
     *
     * @method Phaser.Math#clamp
     * @param {float} v - The value to be clamped.
     * @param {float} min - The minimum bounds.
     * @param {float} max - The maximum bounds.
     * @return {number} The clamped value.
     */
    clamp: function (v, min, max)
    {
        if (v < min)
        {
            return min;
        }
        else if (max < v)
        {
            return max;
        }
        else
        {
            return v;
        }
    },

    /**
     * Clamp `x` to the range `[a, Infinity)`.
     * Roughly the same as `Math.max(x, a)`, except for NaN handling.
     *
     * @method Phaser.Math#clampBottom
     * @param {number} x
     * @param {number} a
     * @return {number}
     */
    clampBottom: function (x, a)
    {
        return x < a ? a : x;
    },

    /**
     * Checks if two values are within the given tolerance of each other.
     *
     * @method Phaser.Math#within
     * @param {number} a - The first number to check
     * @param {number} b - The second number to check
     * @param {number} tolerance - The tolerance. Anything equal to or less than this is considered within the range.
     * @return {boolean} True if a is <= tolerance of b.
     * @see {@link Phaser.Math.fuzzyEqual}
     */
    within: function (a, b, tolerance)
    {
        return (Math.abs(a - b) <= tolerance);
    },

    /**
     * Linear mapping from range <a1, a2> to range <b1, b2>
     *
     * @method Phaser.Math#mapLinear
     * @param {number} x - The value to map
     * @param {number} a1 - First endpoint of the range <a1, a2>
     * @param {number} a2 - Final endpoint of the range <a1, a2>
     * @param {number} b1 - First endpoint of the range <b1, b2>
     * @param {number} b2 - Final endpoint of the range  <b1, b2>
     * @return {number}
     */
    mapLinear: function (x, a1, a2, b1, b2)
    {
        return b1 + (x - a1) * (b2 - b1) / (a2 - a1);
    },

    /**
     * Smoothstep function as detailed at http://en.wikipedia.org/wiki/Smoothstep
     *
     * @method Phaser.Math#smoothstep
     * @param {float} x - The input value.
     * @param {float} min - The left edge. Should be smaller than the right edge.
     * @param {float} max - The right edge.
     * @return {float} A value between 0 and 1.
     */
    smoothstep: function (x, min, max)
    {
        // Scale, bias and saturate x to 0..1 range
        x = Math.max(0, Math.min(1, (x - min) / (max - min)));

        // Evaluate polynomial
        return x * x * (3 - 2 * x);
    },

    /**
     * Smootherstep function as detailed at http://en.wikipedia.org/wiki/Smoothstep
     *
     * @method Phaser.Math#smootherstep
     * @param {float} x - The input value.
     * @param {float} min - The left edge. Should be smaller than the right edge.
     * @param {float} max - The right edge.
     * @return {float} A value between 0 and 1.
     */
    smootherstep: function (x, min, max)
    {
        x = Math.max(0, Math.min(1, (x - min) / (max - min)));

        return x * x * x * (x * (x * 6 - 15) + 10);
    },

    /**
     * A value representing the sign of the value: -1 for negative, +1 for positive, 0 if value is 0.
     *
     * This works differently from `Math.sign` for values of NaN and -0, etc.
     *
     * @method Phaser.Math#sign
     * @param {number} x
     * @return {integer} An integer in {-1, 0, 1}
     */
    sign: function (x)
    {
        return (x < 0) ? -1 : ((x > 0) ? 1 : 0);
    },

    /**
     * Work out what percentage value `a` is of value `b` using the given base.
     *
     * @method Phaser.Math#percent
     * @param {number} a - The value to work out the percentage for.
     * @param {number} b - The value you wish to get the percentage of.
     * @param {number} [base=0] - The base value.
     * @return {number} The percentage a is of b, between 0 and 1.
     */
    percent: function (a, b, base)
    {
        if (base === undefined) { base = 0; }

        if (a > b || base > b)
        {
            return 1;
        }
        else if (a < base || base > a)
        {
            return 0;
        }
        else
        {
            return (a - base) / b;
        }
    }

};
